Accelerating application interrogation and interaction mapping

ABSTRACT

Various embodiments of the present technology generally relate to the characterization and improvement of software applications. More specifically, some embodiments relate to systems and methods for modeling code behavior and generating characterizations of the code behavior and interrelations based on the code models. Some embodiments include user interfaces that provide views into the characterizations and interrelations of the application features and components that can give developers insights quickly and efficiently into applications which may be used for future developments and modifications to the application and to avoid introducing bugs into the application.

CROSS-REFERENCE TO RELATED APPLICATIONS

The present application claims priority to and the benefit of U.S. Provisional Application No. 63/029,027, filed May 22, 2020, entitled “Accelerating Application Modernization,” which is commonly owned and incorporated herein by reference in its entirety for all purposes.

BACKGROUND

Program developers often spend a lot of time working to understand previously written code, especially when modern programs are developed from previously existing applications or code, as they frequently are. In order to understand a program, developers spend time exploring and understanding behavior of existing code and identifying areas to enhance, remove, or modify.

Once a developer understands the behavior and architecture of existing code, it is then the job of the developer to prototype targeted code modules, assemble working code into repositories, understand and review behavior of the code changes, and measure progress towards completion, in addition to other tasks. However, these programmer tasks for understanding and modernizing existing code can be extremely time-consuming and inefficient. Some tools exist to provide details of a feature or component of an application, which may make the developer's review a bit easier. For example, a database tool may provide a schema of a database, or a web services tool may provide information on web service calls made by an application, but these disparate tools do not provide insight into the interactions between the various components of an application. Therefore, a developer that requires information about which database tables are accessed by a given web service, for example, must painstakingly review the codebase to identify such information. Thus, a new system for recording, characterizing, and displaying existing code functionality as well as prototyping new code based on deep knowledge of existing code behavior and additionally to provide insights into interactions between code functionality and components of an application is disclosed.

It is with respect to this general technical environment that aspects of the present technology disclosed herein have been contemplated. Furthermore, although a general environment has been discussed, it should be understood that the examples described herein should not be limited to the general environment identified in the background.

BRIEF SUMMARY

This Summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This Summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used as an aid in determining the scope of the claimed subject matter.

A system of one or more computers can be configured to perform particular operations or actions by virtue of having software, firmware, hardware, or a combination of them installed on the system that in operation causes or cause the system to perform the actions. One or more computer programs can be configured to perform particular operations or actions by virtue of including instructions that, when executed by data processing apparatus, cause the apparatus to perform the actions. One general aspect includes program instructions that instruct a processing device to obtain one or more data files that may include information captured about an application during a run of the application. The system may generate a data library model based on the one or more data files, where the data library model may include one or more steps performed by the application and one or more code paths connecting the steps performed by the application, and the data library model may include information about the application correlated with the one or more steps and the one or more code paths. The system may further provide a user interface for navigating the data library model. Other embodiments of this aspect include corresponding computer systems, apparatus, and computer programs recorded on one or more computer storage devices, each configured to perform the actions of the methods.

Implementations may include one or more of the following features. In some embodiments, the information about the application may include at least one of database schema information, web service information, data structure information, or a combination thereof. In some embodiments, the user interface may include features for filtering the data library model. In some embodiments, the user interface may include navigable data views of the information about the application, and the user interface may include functionality for filtering based on a selection of a data item in a data view by a user to identify other correlated information about the application. The navigable data views may include a navigable view of web services accessed by the application and a navigable view of database schema information used by the application. The user interface further may include functionality for a user to select a web service from the navigable view of web services to identify database schema information related to the selected web service. The user interface further may include functionality for a user to select a data item from the navigable view of database schema information to identify web services related to the selected data item. In some embodiments, the run of the application is requested by a user device remotely from an application server executing the application, and the user interface is accessed by the user device remotely. In some embodiments, the user device generates the one or more data files and transmits the one or more data files to the system. In some embodiments, the run of the application may include executing automated test scripts. Implementations of the described techniques may include hardware, a method or process, or computer software on a computer-accessible medium.

BRIEF DESCRIPTION OF THE DRAWINGS

Many aspects of the disclosure can be better understood with reference to the following drawings. The components in the drawings are not necessarily drawn to scale. Moreover, in the drawings, like reference numerals designate corresponding parts throughout the several views. While several embodiments are described in connection with these drawings, the disclosure is not limited to the embodiments disclosed herein. On the contrary, the intent is to cover all alternatives, modifications, and equivalents.

FIG. 1 illustrates a code modernization and deployment process that may be utilized in accordance with some embodiments of the present technology.

FIG. 2 illustrates a code modernization process that may be utilized in accordance with some embodiments of the present technology.

FIG. 3A and FIG. 3B illustrate an example of an application behavior model that may be generated in accordance with some embodiments of the present technology.

FIGS. 4A-4C illustrate a series of different versions of behavior models that may be utilized to depict design changes between versions in accordance with some embodiments of the present technology.

FIG. 5A illustrates a behavior modeling process in accordance with some embodiments of the present technology.

FIG. 5B illustrates an architecture modeling process in accordance with some embodiments of the present technology.

FIG. 6 illustrates an example of an architecture depiction in accordance with some embodiments of the present technology.

FIG. 7 illustrates an example of a code modernization process in accordance with some embodiments of the present technology.

FIG. 8 illustrates an example of a code modernization process in accordance with some embodiments of the present technology.

FIG. 9 illustrates an example of a code modernization process in accordance with some embodiments of the present technology.

FIG. 10 illustrates an example of a computing system that may be used to perform operations described herein in accordance with some embodiments of the present technology.

FIG. 11 illustrates an exemplary system for performing code modernization and interrogation in accordance with some embodiments of the present technology.

FIGS. 12A-12D illustrate an exemplary user interface providing navigable views of information generated by the system for performing code modernization and interrogation in accordance with some embodiments of the present technology.

FIG. 13 illustrates an exemplary user interface showing filtering and correlation functionality based on the information generated by the system for performing code modernization and interrogation in accordance with some embodiments of the present technology.

FIG. 14 illustrates an exemplary user interface showing drill-down functionality based on the information generated by the system for performing code modernization and interrogation in accordance with some embodiments of the present technology.

FIG. 15 illustrates a method for interrogating and generating information used for filtering and correlating information about an application based on a run of the application in accordance with some embodiments of the present technology.

The drawings have not necessarily been drawn to scale. Similarly, some components or operations may not be separated into different blocks or combined into a single block for the purposes of discussion of some of the embodiments of the present technology. Moreover, while the technology is amendable to various modifications and alternative forms, specific embodiments have been shown by way of example in the drawings and are described in detail below. The intention, however, is not to limit the technology to the particular embodiments described. On the contrary, the technology is intended to cover all modifications, equivalents, and alternatives falling within the scope of the technology as defined by the appended claims.

DETAILED DESCRIPTION

The following description and associated figures teach embodiments and components of code modernization. For the purpose of teaching inventive principles, some conventional aspects of the systems and methods used in the embodiments may be simplified or omitted. Those skilled in the art will appreciate variations from the described embodiments that fall within the scope of the present disclosure. Those skilled in the art will appreciate that the features described below can be combined in various ways to form multiple variations that fall within the scope of the present disclosure. As a result, the disclose is not intended to be limited to the specific examples described below.

Various embodiments of the present technology generally relate to modernization of software applications. More specifically, some embodiments relate to a system for increasing the efficiency of application development by characterizing existing code and prototyping new code for a target language or environment. The present technology uses a combination of methods to interrogate code and characterize applications and features. In an embodiment, a system runs and records the run of an application. A high-level view of the code is created based on the recording by rolling up the data captured in low-level recordings. Based on the recording, the system characterizes the application, or at least one specific feature of the application, and depicts the characterization using graphical visualizations. The recording may then be used in machine learning-assisted prototyping where new code may be suggested or cases tested. New code may be deployed to a target environment, in which the behavior of the new code can be compared and approved.

In some embodiments, the characterizations may be interrelated such that information within the characterizations may be used to drill down within the code characteristics to identify interdependencies within the code. A developer may use a user interface to view, drill down, and filter the characterizations to identify specific information about features and interrelations between components and features. As an example, a developer intending to modify a database table may be able to find all interdependencies within the code and all web services so that he may ensure he does not introduce a bug into the application by modifying the table. Without the tool to generate the modernized code and characterizations, the developer would have to manually review all of the code to find all instances and use debugging software to identify as many missed instances as possible, and end users may still then identify some issues. The present code modernization and characterization minimizes the time needed by the developer to identify all relevant interrelations within the application and address them before releasing the modification.

Aspects of the technology disclosed herein provide for recording and characterizing applications or features of existing or previously written code (i.e., legacy code). Prior to characterizing the code, a computing system in accordance with the present technology may record a run of the existing code. The computing system interprets the code behavior by isolating features and provides a deep characterization of dependencies, logic, and data queries. In the application behavior model, the way the code works can be broken down into clear features and/or steps that can be understood and used by developers. In some examples, a behavior model includes labeling of functional areas of code. The application may be rolled up to create a holistic platform architecture depiction representing code architecture and features. Steps performed by the code may be broken down and displayed in a graphical manner, where the portions of the code are represented in a natural-language manner. For example, after the code is run and recorded, a graphical representation may show that first a session was created, then a username and a password were collected, then a check was performed to see if two-factor authentication was enabled, then settings for the user were checked, then the system checked if the request was coming from a banned internet protocol (IP) address, and finally a dialogue was opened.

It should be noted that recording a run of the code provides distinct advantages over reading the code and trying to build a behavior model based on the reading. In a recording, a behavior modeling system in accordance with the present disclosure may observe a program performing many different tasks and interrogate the recording to analyze an underlying behavior, essentially performing a software audit. The present technology does not need to use or read existing code verbatim when modernizing code and can represent the behavior of a program in a natural language and/or graphical manner. Further, the interrogation can be performed using test cases or can by performed using machine learning to probe the code in an exhaustive manner, ensuring the application has been thoroughly interrogated. The interrogation may allow characterization of components as well as interdependencies between the many features and components within an application. A logic flow of the code (i.e., a conceptual program) is created that serves as an intermediate representation of the program. The intermediate representation can then be used to generate code that mimics the behavior of the existing code or behaves similarly to the existing code, even if the new code is generated in a different language for a different environment. Building new code based on a behavioral model rather than trying to translate from one language or environment to another provides a distinct advantage over previous technologies and produces a better end result by generating new code according to a target language and environment based on a desired behavior rather than an attempted translation.

In some embodiments, the information collected during the recording may then be analyzed using artificial intelligence-assisted prototyping based on a database of code and feature data. The analysis may then be used to suggest new code or test cases. The previously developed behavior model may serve as the basis for intelligent code suggestions performed in a machine learning engine. The machine learning engine, in some embodiments, analyzes and interprets code behavior across various repositories and languages. The machine learning engine may recognize, learn, categorize, anticipate, and recommend robust designs for application behavior. The engine may generate prototype code for any language or target platform.

The new code may subsequently be packaged for deployment within a target system or environment. The generated prototype code includes deployment packaging in some examples, eases developer ramp-up on new deployment platforms, and ensures uniformity of deployment code. Finally, the new code may be behaviorally compared to predicted or desired behaviors, or to the behavior of older versions, prior to approval. The design changes may be presented such that the different versions can be easily compared. Old and new code can be visually represented in order to evaluate correctness, robustness, and security.

In addition to the ability to generate new code, the information collected during the recording may be analyzed using artificial intelligence-assisted analysis components that generate characterizations of the code, including interdependencies between the features and components of the code to provide detailed views and overviews of the characterizations to the developer. User interfaces can be used by the developers or users to view the characterizations and drill down or filter the characterizations to identify the interdependencies that are relevant for that user or developer.

FIG. 1 illustrates an exemplary code modernization process 100 in accordance with certain aspects of the present technology. In process 100, code 105 represents an existing code that is used to generate modernized code 120. Based on code 105, behavior model 110 is created. In certain implementations, a code modernization system records a run of code 105 to generate behavior model 110. Various sources of data may be utilized when recording code 105 or another codebase in accordance with the present technology. Data may be derived from static analysis (e.g., code repository scan) and dynamic analysis of code including case testing and unsupervised learning and fuzzing, in additional to similar sources of data for understanding functionality of a codebase and combinations thereof. Based on the static and dynamic analyses of code 105, behavior model 110 is generated.

Behavior model 110 may include the labeling of functional areas of code such as Structured Query Language (SQL) execution, Hypertext Transfer Protocol (HTTP) web services, and security-related functions (e.g., networking, unfiltered user input, SQL generation, authentication and authorization, cryptography, and the like) in addition to other functional areas of code that may exist in a codebase. Behavior model 110 may depict various code paths or scenarios performed in the recorded execution of the code, wherein each code path or scenario may be individually modeled and interpreted in some examples. The individual code paths or scenarios of behavior model 110 may be rolled up to create an architecture depiction of the codebase. The architecture depiction may serve as a holistic platform architecture model that can be utilized by a developed or similar user to understand or interact with aspects of the codebase. In some implementations, aspects of the code may be depicted in a natural-language manner for ease of use and accessibility to a user.

Behavior model 110 or information extracted from behavior model 110 may then be used as the basis for intelligent code suggestions. In process 100, behavior model 110 is used as input to a machine learning engine represented by neural network 115. The machine learning engine then analyzes and interprets (i.e., understands) code behavior across repositories and languages. The machine learning engine may use the information provided to identify, learn, categorize, anticipate, and recommend designs for an application that mimics or behaves similarly to code 105. From the machine learning engine, a code sketch, (i.e., modernized code 120) is generated for any code language and target platform. In some examples, the machine learning engine generates a plurality of prototype codes for any language and target platform. Examples of code languages include but are not limited to JavaScript, Go, Python, .NET, Java, C, C++, Swift, Ruby, Objective-C, HTML, Fortran, APL, Perl, SQL, and Generated prototype code. In some embodiments, the output includes deployment packaging to ease developer ramp-up on new deployment platforms. By including deployment packaging, the uniformity of deployment code can be ensured. Thus, modernized code 120 is deployed to target environment 125. Target environment 125 may be any computing platform suitable for running modernized code 120 including but not limited to a personal computing environment, a time-sharing computing environment, a client server computing environment, a distributed computing environment, a cloud computing environment, or a cluster computing environment. In some examples, target environment 125 comprises a computing service such as Amazon Web Services (AWS) Lambda, Microsoft Azure, Google Container Engine, Red Hat OpenShift, Kubernetes, IBM Cloud Foundry, Oracle Cloud Platform, or a similar computing environment.

In some embodiments, once modernized code 120 is deployed in target environment 125, behavior modeling techniques described herein may be used to compare the behavior of modernized code 120 to the behavior of code 105, expected behavior, desired behavior, or variations or combinations thereof. Behavior modeling techniques described herein can be utilized to understand design changes between versions of code and allow a user to visualize old and new code to evaluate correctness, robustness, and security.

FIG. 2 illustrates an example of an application modernization process in accordance with certain embodiments of the present technology. Process 200 begins with application 205. Application 205 may be any application for which a user wishes to generate a modernized version. In some scenarios, application 205 was previously developed, and a user wishes to create a similar application in a new language or for a new environment. In the present example, the behavior modeling technology described herein is used for automatic prototyping of programs. Application 205 is provided to application modernization system 210 and application modernization system 210 generates modernized application 215. Application modernization system 210 may generate a behavior model and/or an architecture model based on a recording of a run of application 205 and use the behavior model and/or architecture model to generate modernized application 215 based on a target language and a target platform. In some embodiments, application modernization may enable display of a graphical version of the behavior model and/or the architecture model, while in other embodiments, application modernization system may automatically generate modernized application 215 without enabling display of graphical versions of the one or more models.

FIG. 3A and FIG. 3B illustrate graphical depictions of a behavior model that may be displayed for a user in accordance with aspects of the present technology. Behavior model 300 is generated based on low-level recordings of a program. Behavior model 300 begins with get scenarios block 301 from which scenario 305, scenario 310, scenario 315, scenario 320, and scenario 325 originate. Each of the scenarios shown includes a code path with one or more propagating steps. For example, scenario 305 begins with step “Find User by ID” and ends with a “SQL Select” step. Scenario 310 begins with step “Find Scenario” and ends with a “SQL Select” step. Scenario 315 begins with step “Find Has Key Stats Code Object Counts,” the output of which feeds to “Count Code Object Table,” the output of which feeds to “Count Code Object,” and ends in a “SQL Select” step.

Scenario 320 begins with step “Find Has Key Stats Key Stats Counts,” the output of which feeds to “Count Key Data Stats Table.” “Count Key Data Stats Table” provides output to three separate “Count Key Data Stats” blocks each of which provide output to a “SQL Select” step. The final code path shown in behavior model 300, scenario 325, begins with block “Show Scenario Controller,” which provides its output to “Feature Scenario Show,” which provides an output to a “SQL Select” step.

In addition to the connections and code paths discussed in behavior model 300, it is shown in FIG. 3B that several additional connections exist wherein information may be provided to code blocks. A connection exists between the ID output of get scenarios block 301 and the ID input of the find scenario block in scenario 310. Similarly, a connection exists between the scenario show output of the find scenario block of scenario 310 and the scenario show input of the feature scenario show block of scenario 325. The connections shown serve to exemplify the types of relationships that can be modeled in behavior model 300. Additional relationships, scenarios, block types, connections, code paths, and the like may exist and are anticipated herein.

Behavior model 300 may be presented in a user interface to help a user to understand code behavior, in some examples. Scenarios from the low-level recordings in behavior model 300 may be rolled up into a high-level view of the code architecture in some embodiments. The high-level architecture view may also be presented in a user interface to help a user understand code behavior and structure. Information from behavior model 300 may be used to generate new code that behaves similarly to or mimics the behavior of an existing program, regardless of whether any models are displayed in a user interface.

FIG. 4A, FIG. 4B, and FIG. 4C illustrate behavior models of different versions of a program in accordance with some embodiments of the present technology. In some examples, each of behavior model 400, behavior model 410, and behavior model 420 may be displayed in a user interface such that a user may visually compare them to one another. In FIG. 4A, behavior model 400 represents a first version of the program. The first block of behavior model, block 401, includes a “Get Scenarios” block, which provides output to block 402, a “Find Scenario” block, which provides output to block 403, a “SQL Select” block.

FIG. 4B includes behavior model 410, which represents a subsequent version of the program. Behavior model 410 includes additional blocks, additional code paths, and additional relationships to the first version shown in FIG. 4A. In FIG. 4B, behavior model 410 begins at a get scenarios block, block 411. Block 411 provides output to two code paths. In the upper code path, block 412 receives input from block 411 including ID information. Block 412 provides output to block 413, a SQL select block. Block 412 also provides scenario show information to block 415. Block 414, show API scenarios controller block, receives input from block 411 and outputs to two blocks: block 415, last scenario show modified date, and block 417, SQL select. Block 415 outputs to block 416, SQL select.

FIG. 4C includes behavior model 420 which represents a final version of the program. Behavior model 420 begins at block 421, a get scenarios block, which outputs to three distinct code paths. The upper code path starts with block 422, find user by ID, which outputs to block 423, SQL select. The middle code path starts with block 424, find scenario, which outputs to block 425, SQL select. Block 424 also outputs scenario show information to block 427. The lower code path starts at block 426, show API scenarios controller, which provides output to block 427, last scenario show modified date, and block 429, SQL select. Block 427 outputs to block 428, SQL select.

FIG. 4A, FIG. 4B, and FIG. 4C serve to illustrate the advantages provided by the ability to visualize old and new code, or different versions of code, nearby one another or side-by-side. Behavior model 400, behavior model 410, and behavior model 420 may be displayed in a user interface to help a developer or another user understand design changes from one version to the next. Visualizing different versions of a program in this manner enables simple evaluation of correctness, robustness, and security, in addition to other program considerations and factors.

FIG. 5A illustrates process 500 for generating a behavior model in accordance with certain aspects of the present technology. In process 500, static code analysis and dynamic code analysis are used as inputs to behavior modeling system 505. Behavior modeling system 505 then produces behavior model 510 based on these inputs. Behavior modeling system 505, in accordance with some embodiments of the present technology, extracts information from a recording of a program to generate behavior model 510. In order to do this, behavior modeling system 505 filters through the data in the recording to identify steps, scenarios, components, subcomponents, and features of the program. In some implementations, the present technology is used for behavior modeling without code generation. Behavior modeling may serve to assist developers understand a program on multiple levels and does not require the generation of new code.

FIG. 5B illustrates process 515 for generating an architecture model from behavior model 510. Behavior model 510 is first divided into its identified code paths. In the present example, behavior model 510 includes code path 520, code path 525, and code path 530, which may each be used to make up their own behavior model representing a subset of behavior model 510. These behavior models of individual scenarios may then be used by architecture modeling system 535 to generate architecture model 540 in which features of the application are labeled and categorized. A holistic platform architecture model may be embodied in many different manners from those described herein and the architecture model depiction shown here and in FIG. 6 is provided solely for purposes of explanation. Architecture modeling system 535 rolls up the application code paths into architecture model 540, in which different features of the application may be modeled and shown in a high-level view that can be drilled into by a user for lower-level data.

FIG. 6 illustrates an example of an architecture depiction in accordance with certain aspects of the present technology. Architecture model 600 shows a high-level depiction of a program and includes six classes of components: controllers 605, helpers 610, jobs 615, models 620, serializers 625, and lib 630. A developer or user interacting with architecture model 600 may select a class or function to find more information (i.e., lower level information) on the class or function. The blocks shown (i.e., features) within each component class of architecture model 600 may be selected in a user interface to enable a developer or other user to drill down into more detail regarding that aspect of the program. Architecture model 600 may be used to illustrate packages, classes, functions, SQL queries, server requests, messages, and the like in addition to different feature groups such as activity, authentication, notifications, post authoring, and the like.

Information may be presented in a natural language manner such that features of the application can be understood from a behavior or architecture standpoint. For example, activity features may include descriptions such as “page view requests are recorded,” “record the number of times which a topic is viewed,” “topic user activity is recorded,” “user timing activity on a post and last read information is recorded,” “user timing activity on a topic is recorded,” and similar. Examples of authentication features may include, “login via user interface,” “login with credentials,” “login with valid credentials,” “logout an active user session,” “user logs in successfully,” and similar. An example of a notification feature may include “user can ignore another user for a specific amount of time” or similar. An example of a post authoring feature may include “a user who created a topic can delete posts from it” or similar. As previously mentioned, architecture model 600 is not intended to limit the scope of the architecture modeling technology and is provided solely for purposes of explanation.

FIG. 7 is a flow chart illustrating process 700 for modernizing code in accordance with embodiments of the present technology. In step 705, an application modernization system records an existing codebase. Recording an existing codebase is different from reading existing code. To record an existing codebase, the system records a run of the code and uses dynamic and static data analysis to identify what the application is doing from a functionality and behavior standpoint. Based on the recorded information, the application modernization system generates a behavior model in step 710. The behavior model may take a form similar to that shown in the preceding Figures or may differ in appearance or functionality. In some examples, the behavior model is displayed in a user interface such that a developer may use the model to understand the code behavior. In other examples, a graphical version of the behavior model is not created for display in a user interface and is solely for purposes of use by the application modernization system when generating new code. Generating the behavior model may include identifying and labeling one or more functional areas of code, identifying one or more code paths connecting steps performed by the existing code, and identifying important decision points and code branches between functional areas of the existing code.

In step 715, the behavior model is used to suggest new code and test cases. The new code, in some examples, mimics the behavior of the existing program. In some examples, suggesting new codes and testing cases utilizes a machine learning engine in which the behavior model is used as input to one or more machine learning algorithms that may include but is not limited artificial neural networks. Cases may then be tested with the new code to ensure robustness, accuracy, security, and the like. In step 720, the application modernization system deploys the new code to a target environment. In some examples, a target language and target environment are identified before generating the new code and deploying the new code is performed based on the identified information. Once the new code is deployed to the target environment, the behavior of the new code can be compared to predicted behavior or existing code behavior in step 725.

In some embodiments of the present technology, an application modernization system runs in any staging environment used by a developer or user. For example, the application modernization system may be a plug-in or similar agent to a staging environment such that it is integrated into the environment for recording application runs. The system may be a browser plug-in in some implementations. In an embodiment of the present technology, a user indicates to the application modernization system, via the plug-in or agent, to start recording. The user may then run the application and stop the recording when its finished running. The data may then be sent to another window, a client browser extension, a pop-up, another application, or similar that can then show and be used to interact with the data and flow diagram showing what the application does.

FIG. 8 is a flow chart illustrating process 800 for application behavior modeling in accordance with aspects of the present technology. In step 805, an application modernization system records a run of existing code. In some examples, the run is recorded by a plug-in or similar agent in a staging environment. In step 810, the application modernization system characterizes existing code behavior and generates a behavior model and an architecture model. Characterizing existing code behavior and generating the behavior model may include identifying and labeling one or more functional areas of code, identifying one or more code paths connecting steps performed by the existing code, and identifying important decision points and code branches between functional areas of the existing code, in some embodiments.

In step 815, the behavior model and architecture model are displayed. In some implementations, the application modernization system enables display of the behavior model and the architecture model in a user interface of a computing device. In step 820, the application modernization system receives a selection of a feature in the architecture model. In some examples, this comprises a developer or user selecting a block from an architecture model such as in architecture model 600. In step 825, the application modernization system drills into the selected feature and provides lower level information related to the feature. In some embodiments, features may be determined automatically by an application modernization system as described herein. The system may use information about web services, commands, background jobs, or similar entry points into an application to automatically identify features that may then be presented to a user and drilled into for access to the lower level information.

FIG. 9 is a flow chart illustrating process 900 for modernizing code in accordance with some embodiments of the present technology. In step 905, an application modernization program records a run of an existing application. Based on the run of the existing application, the application modernization system generates a behavior model in step 910. In some examples, the behavior model is similar to the behavior models described in reference to the preceding Figures. The behavior model may be displayed in a user interface for use by a developer or other user, or the behavior model may not be displayed at all and solely used by the system for purposes of generating new code based on the behavior model. In step 915, the application modernization system generates an architecture depiction of the application. In some examples, generating the architecture depiction includes rolling up individual code paths from the behavior model to generate a high-level depiction of the codebase architecture. In some examples, the architecture depiction is displayed in a user interface for use by a developer or other user.

In step 920, the application modernization system receives a class or function select as input prior to generating a new version of the application. A target language and target environment are also indicated to the application modernization system. In step 925, the application modernization system generates new code based on the target language or target platform. The new code is not a translation of the existing application. The new code is generated based on the generated models such that the new code is written in a way more conducive to the new language, platform, or environment. In some embodiments, generating the new code uses machine learning techniques. Machine learning techniques may be used to optimize new codes based on their target languages and environments. In some examples, the machine learning techniques comprise one or more trained neural networks that take information from the behavior model and/or architecture model as input and generate a program that mimics the behavior of the existing application or behaves similarly to the existing application.

In step 930, the application modernization system deploys the new code to the target environment. Once the new code is deployed, the application modernization system may compare the behavior of the new code to the behavior of the existing application, or may approve or reject the new code. In some examples, the behavior of the new code is also compared to predicted behaviors, desired behaviors, or the like. Code versions may be compared in one or more windows of the application modernization system as discussed in reference to the preceding Figures.

FIG. 10 illustrates computing system 1001 to perform application modernization according to an implementation of the present technology. Computing system 1001 is representative of any system or collection of systems with which the various operational architectures, processes, scenarios, and sequences disclosed herein for application modeling and modernization may be employed. Computing system 1001 may be implemented as a single apparatus, system, or device or may be implemented in a distributed manner as multiple apparatuses, systems, or devices. Computing system 1001 includes, but is not limited to, processing system 1002, storage system 1003, software 1005, communication interface system 1007, and user interface system 1009 (optional). Processing system 1002 is operatively coupled with storage system 1003, communication interface system 1007, and user interface system 1009.

Processing system 1002 loads and executes software 1005 from storage system 1003. Software 1005 includes and implements application modernization process 1006, which is representative of the application modernization discussed with respect to the preceding Figures. When executed by processing system 1002 to provide application modernization functions, software 1005 directs processing system 1002 to operate as described herein for at least the various processes, operational scenarios, and sequences discussed in the foregoing implementations. Computing system 1001 may optionally include additional devices, features, or functionality not discussed for purposes of brevity.

Referring still to FIG. 10, processing system 1002 may comprise a micro-processor and other circuitry that retrieves and executes software 1005 from storage system 1003. Processing system 1002 may be implemented within a single processing device but may also be distributed across multiple processing devices or sub-systems that cooperate in executing program instructions. Examples of processing system 1002 include general purpose central processing units, graphical processing units, application specific processors, and logic devices, as well as any other type of processing device, combinations, or variations thereof.

Storage system 1003 may comprise any computer readable storage media readable by processing system 1002 and capable of storing software 1005. Storage system 1003 may include volatile and nonvolatile, removable and non-removable media implemented in any method or technology for storage of information, such as computer readable instructions, data structures, program modules, or other data. Examples of storage media include random access memory, read only memory, magnetic disks, optical disks, optical media, flash memory, virtual memory and non-virtual memory, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other suitable storage media. In no case is the computer readable storage media a propagated signal.

In addition to computer readable storage media, in some implementations storage system 1003 may also include computer readable communication media over which at least some of software 1005 may be communicated internally or externally. Storage system 1003 may be implemented as a single storage device but may also be implemented across multiple storage devices or sub-systems co-located or distributed relative to each other. Storage system 1003 may comprise additional elements, such as a controller, capable of communicating with processing system 1002 or possibly other systems.

Software 1005 (including application modernization process 1006) may be implemented in program instructions and among other functions may, when executed by processing system 1002, direct processing system 1002 to operate as described with respect to the various operational scenarios, sequences, and processes illustrated herein. For example, software 1005 may include program instructions for implementing a code modeling and prototyping system as described herein.

In particular, the program instructions may include various components or modules that cooperate or otherwise interact to carry out the various processes and operational scenarios described herein. The various components or modules may be embodied in compiled or interpreted instructions, or in some other variation or combination of instructions. The various components or modules may be executed in a synchronous or asynchronous manner, serially or in parallel, in a single threaded environment or multi-threaded, or in accordance with any other suitable execution paradigm, variation, or combination thereof. Software 1005 may include additional processes, programs, or components, such as operating system software, virtualization software, or other application software. Software 1005 may also comprise firmware or some other form of machine-readable processing instructions executable by processing system 1002.

In general, software 1005 may, when loaded into processing system 1002 and executed, transform a suitable apparatus, system, or device (of which computing system 1001 is representative) overall from a general-purpose computing system into a special-purpose computing system customized to provide application modernization functions as described herein. Indeed, encoding software 1005 on storage system 1003 may transform the physical structure of storage system 1003. The specific transformation of the physical structure may depend on various factors in different implementations of this description. Examples of such factors may include, but are not limited to, the technology used to implement the storage media of storage system 1003 and whether the computer-storage media are characterized as primary or secondary storage, as well as other factors.

For example, if the computer readable storage media are implemented as semiconductor-based memory, software 1005 may transform the physical state of the semiconductor memory when the program instructions are encoded therein, such as by transforming the state of transistors, capacitors, or other discrete circuit elements constituting the semiconductor memory. A similar transformation may occur with respect to magnetic or optical media. Other transformations of physical media are possible without departing from the scope of the present description, with the foregoing examples provided only to facilitate the present discussion.

Communication interface system 1007 may include communication connections and devices that allow for communication with other computing systems (not shown) over communication networks (not shown). Examples of connections and devices that together allow for inter-system communication may include network interface cards, antennas, power amplifiers, radiofrequency circuitry, transceivers, and other communication circuitry. The connections and devices may communicate over communication media to exchange communications with other computing systems or networks of systems, such as metal, glass, air, or any other suitable communication media. The aforementioned media, connections, and devices are well known and need not be discussed at length here.

Communication between computing system 1001 and other computing systems (not shown), may occur over a communication network or networks and in accordance with various communication protocols, combinations of protocols, or variations thereof. Examples include intranets, internets, the Internet, local area networks, wide area networks, wireless networks, wired networks, virtual networks, software defined networks, data center buses and backplanes, or any other type of network, combination of networks, or variation thereof. The aforementioned communication networks and protocols are well known and need not be discussed at length here.

FIG. 11 illustrates a system 1100 for performing code interrogation and interaction mapping according to some embodiments. The system 1100 may include a user component 1105, an application component 1110, and an analysis component 1115. The methods of performing code modernization and interrogation as described with respect to FIGS. 1-9 may be performed on a single computing system 1001, in some embodiments. In such embodiments, the user component 1105, application component 1110, and analysis component 115 all reside in a single computing device and are configured to communicate with data sources 1140, which may or may not reside on the same computing device. However, in some embodiments, it may be beneficial for a user to not be required to have knowledge for creating the complete environment on a single system for performing such methods. Accordingly, in some embodiments, the user component 1105, application component 1110, and analysis component 1115 may be distributed among more than one computing system.

User component 1105 may be a computing system such as computing system 1001 having memory one or more processors, communication components, and the like which are not included in user component 1105 for simplicity of description. In some embodiments, user component 1105 is a component on a computing system. User component 1105 may include user interface 1122 and user interface component 1120. User interface 1122 may provide a user interface to application 1125. User interface component 1120 may provide an interface component that allows a user to instantiate the code modernization and interrogation process remotely. For example, user interface component 1120 may include a browser extension within an internet browser displaying the user interface 1122. The browser extension may generate calls to recording component 1130. In some embodiments, user interface component 1120 may be a standalone program executing on the user component 1105. The user interface component 1120 may be configured to communicate with user interface 1122 for tracking the status of user interface 1122. User interface component 1120 may allow the user to initiate code modernization and interrogation without specific knowledge of setting up the application 1125 and any associated data sources 1140, the remote recording component 1130, and the analysis engine 1135. For example, as discussed, user interface component 1120 may include a browser extension such that the user is accessing a remote user interface 1122 of the application 1125 via an internet browser, and the user may initiate recording of the application 1125 behavior by the remote recording component 1130 by clicking a button within the browser generated by the browser extension. User interface component 1120 may be implemented as software instructions residing in memory of remote computing system 1105 that are executed by one or more processors of remote computing system 1105. In some embodiments, when used on a single machine, the user may have to configure and set up each of the described components. As such, the user interface component 1120 may still allow the user to interact with the application component 1110 via a user interface that may differ from any user interface offered by the application 1125.

Application component 1110 may be a computing system such as computing system 1001 having memory, one or more processors, communication components, and the like which are not included in application server 1110 for simplicity of description. In some embodiments, application component 1110 is a component on a computing system. Application component 1110 may include application 1125 and recording component 1130. Application 1125 may be compiled code ready for execution, which may be an application, such as application 205 as described with respect to FIG. 2, or code 104, as described with respect to FIG. 1. Recording component 1130 may include a message handler that receives messages to begin recording from the user interface component 1120. The remote recording component 1130 may record the execution or run of application 1125 for a predefined period of time or, as another example, until a stop recording message is received from user interface component 1120. In some embodiments, recording component 1130 may transmit an execution command to application 1125 to initiate execution of application 1125 for recording the behavior. In some embodiments, recording component 1130 may transmit a command or request for application 1125 to execute test cases for exploring behavior of application 1125 and/or user interaction with application 1125. For example, in some embodiments, application 1125 may be a web service provided via user interface 1122. The test cases may cause the user to interact with user interface 1122, and the behavior of the interaction may be recorded by recording component 1130. Recording component 1130 may generate one or more data files that contain the important or relevant information about the behavior of application 1125 during the run. In some embodiments, machine learning or other artificial intelligence may be used to probe the codebase of the application 1125 intelligently until avenues are exhausted to get a complete run of all aspects of the application 1125. Recording component 1130 stores the behavior information in data files based on recording and, in some embodiments, analyzing the run while executing and/or after execution based on recorded information. Such information is described above with respect to FIGS. 1-9, and it may include information about the code behavior based on isolating features and providing a deep characterization of dependencies, logic, and data queries. The information recorded and stored in the data files may include information about the application including database schema information used by the application, web services accessed by the application, functions of the application, data structure information in the application, and the like. In some embodiments, the recording component 1130 analyzes the behavior to store specific information about calls made, web services accessed, links accessed, data queries, database schema interpretation information, functional areas of the application or code, code paths taken, and the steps performed, and the like. Recording component 1130 and application 1125 may be implemented as software instructions residing in memory of application server 1110 that are executed by one or more processors of application server 1110.

Analysis component 1115 may be a computing system such as computing system 1001 having memory one or more processors, communication components, and the like which are not included in analysis component 1115 for simplicity of description. In some embodiments, analysis component 1115 is a component on a computing system. Analysis component 1115 may include analysis engine 1135. Analysis engine 1135 may receive the data files from recording component 1130. Using the data files, analysis engine 1135 may generate the behavior model, such as, for example behavior model 110, 400, 410, or 420. Additionally, analysis component 1115 may generate a data library model. The data library model may include steps performed by the application and code paths connecting the steps performed by the application. The data library model may also include information about the application correlated with the one or more steps and the one or more code paths. For example, the data library model may include information about the application including database schema information, web service information, data structure information, and the like, or any combination of such information. Additionally, data library model may include information correlating the information about the application. For example, the database tables or other data elements in the database may be correlated with web services and or functions that access the specific database elements. The information about the interrelations may be used to provide valuable insights to the user via the user interface 1122, which is discussed further in the following figures. As described above with respect to FIGS. 1-9, analysis engine 1135 may generate a graphical depiction based on the behavior model, such as described with respect to FIGS. 3A-6 or perform other analysis of application 1125 as described herein based on the data files. Graphical depictions based on the data files may be generated by the analysis engine 1135 as shown with respect to FIGS. 12-14. In some embodiments, analysis engine 1135 may make the depictions available to the user via, for example, the user interface component 1120. Analysis engine 1135 may be implemented as software instructions residing in memory of analysis component 1115 that are executed by one or more processors of analysis component 1115.

Note that there are numerous advantages to the analysis of the data files for automatic generation of information about the application that includes correlated information about the various functionality and components of the application. For example, information about database schemas is difficult to obtain. Typically, there is not good documentation. Even if there is good documentation, the process of creating and reviewing the documentation is painstaking. Further if the information about the database schema does not exist, one cannot obtain the information without access to the database, which is not generally available for security reasons and because database administrators do not grant such access. Similarly, the web services information would be obtained from API documentation if it were generated by the developer. Ultimately, even though some tools exist, for example, to generate database schema information, those tools provide a set of information about a single aspect of the application. As such, one still needs to painstakingly review all of the various bits of information to find correlations and interactions. Using the systems and methods disclosed herein, an aggregated view that provides a broad picture of the application. Further, the underlying information is correlated, so it can be drilled into, navigated, and filtered to obtain answers that would not previously be possible without hours of manual labor. For example, using the user interface to interact with a navigable view of the data schema, one may select a portion of the data schema and see which parts of the code are relevant to that portion of the data schema. All of the interrelated or correlated portions of the application can be navigated and filtered similarly to allow a developer to quickly obtain a view of the application and interactions. This can provide useful information for modifications to the code, for example, such that a developer can find all portions of the code impacted by a change to that portion of the data schema, as an example. One can see the value of seeing the interactions between the code functions, the code paths, the database schema, the web services, and so forth, such that all the interactions and interrelations can be quickly identified. This type of interrelation information is previously unavailable.

FIG. 12A illustrates an exemplary user interface 1200 that is generated based on the data files generated based on runs/executions of the application, such as application 1125. In some embodiments, the test scripts or execution of the application is not complete. The data files may include information about the application that is captured during the runs, which may not be exhaustive. The user interface 1200 includes insights that may be useful to the user or developer about the application. For example, properties box 1205 includes property information about the application including languages used, frameworks used, platforms used, the type of system, repositories used, and the number of scenarios run that the information is based off of. The number of scenarios may be the number of test cases executed and information aggregated and analyzed to generate the data in the user interface 1200. In this example, 4 scenarios or test cases were used. In an exhaustive run, many scenarios, for example hundreds of scenarios may be used. The user interface 1200 also includes information about the code structure of the application in the code structure box 1210. The code structure information may include the number of packages, the number of classes, the number of functions, the number of SQL queries, the number of HTTP server requests, and the number of messages exchanged. The user interface may also include data source box 1215, which may indicate the source of the data used to generate the information in the user interface 1200. In this example, the data sources are all automated tests, and as already discussed, there were 4 scenarios (i.e., 4 automated tests were run in this example).

Below the insights, the user interface 1200 may include data model information. The data model information may include a listing of the entities in the database schema shown in entities listing 1220. The data model information may also include a graphical depiction of the database schema as shown in schema box 1225.

FIG. 12B illustrates further information shown by user interface 1200 when the user scrolls down the page. Illustrated in more detail are the entities box 1220 and the schema box 1225. The entities box may allow the user to select an entity to drill further in to find which tables, columns, rows, data structures, and data items exist in the data model. As a visually graphical view, the schema box 1225 also provides the entities in a graphical depiction that includes interrelations between the entities. For example, the entity mapsets has a connection with the entity scenarios based on the information gathered from the run of the application in this example.

FIG. 12C illustrates further information shown by user interface 1200 when the user scrolls down the page. For example, functional data may be included in the packages box 1230. The packages box 1230 may include organization and code density visually for the user based on the functions executed during the run of the application. For example, the graphical information may indicate that the ApiKey function is larger/more dense than the search function. This functional view of the code may provide an opportunity for the user to further drill into the functions and filter based on functions to identify correlated or interrelated information. For example, selection of the classmap 1235 (e.g., by clicking on the location on the screen) may allow the user to drill down into the details of the classmap 1235. Additionally, selection of the classmap 1235 may provide information about other features of the application correlated with the classmap 1235. For example, selection of the classmap 1235 may filter the data for viewing such that the user may see which data items in the data model are correlated with the classmap 1235. For example, the classmap 1235 may particularly call various table with the database, and such entities may then be provided for further review to the user. In this way, the underlying data allows the user to drill down into functions as well as find correlated information including web services information, database schema information, and other related functions, as some examples.

FIG. 12D illustrates further information shown by user interface 1200 when the user scrolls down the page. For example, web service data may be included in the web resources box 1240. And further detail related to a selected resource may be shown in the details box 1245. As shown in FIG. 12D, the web service information may include the number of routes and the number of requests identified by the run of the application. In this example, 32 routes and 142 requests were identified to generate the information shown. The resources box 1240 may show the web service resources listing for the user to select from, drill into, and filter for further information. In the example shown, the login resource 1250 is selected, and the details of the login resource 1250 are displayed in the details box 1245. In this example, the login resource 1250 was generated using three routes and 10 requests. In the details box, the three different routes are shown. The first route used method “GET” and the route was “/login.” Seven scenarios (e.g., test cases) used this route. The second route used method “POST” and the route was “/login.” Two scenarios (e.g., test cases) used this route. The third route used method “GET” and the route was “/login/github.” This may be a service that allows the user to login via a successful login to github. One scenario used this route.

The user interface 1200 shown in FIGS. 12A-12D show exemplary data and provide exemplary information about the application based on an exemplary number of test cases/scenarios of the application. The data may be different depending on the application run and the number of scenarios used. Additionally, the data shown including the insights, data models, functions, and web services are exemplary types of data. While these may be useful, they may not always all be included. Further, other types of information may also be included that is captured from execution of the application without departing from the scope of the disclosure. Finally, the information may be provided in a different layout or design including being on different pages rather than scrolling, in a different order, and the like.

FIG. 13 illustrates an exemplary user interface 1300. The user interface 1300 may be generated based on a filtering request selected by the user. For example, the user may have selected the “users” entity from the entities box 1220 depicted in FIG. 12B. The user may have selected to filter the web services based on the “users” entity. As a result, only the web services that access the users entity in the data model are shown due to the filter. In this example, the resources box 1305 is reduced to four resources that utilize the “users” entity in the data model. This allows the developer to quickly see that a modification to the “users” entity may impact any of these four web service resources. Additionally, the routes and request depicted are limited to those that actually utilize the “users” data entity. For example, the selection of the login resource 1315 shows 2 routes and 9 requests, whereas, before the filtering, the login resource 1250 showed 3 routes and 10 requests. The two routes that are left after filtering are shown in the details box 1310 when the user selects the login resource 1315. Note that this type of correlation was previously not able to be automatically generated and provided timely to a user. In fact, for any but the absolute smallest of applications, this information could not be reasonably generated because the time and effort it may take would not be possible. Further, a person could not reasonably follow all the paths to generate such a correlated mapping of functions, web services, database schema, and other information in an application.

FIG. 14 illustrates an exemplary user interface 1400 that shows additional correlation information and drill down functionality. In this example, the user may have selected the post login route 1320 by, for example, double clicking or right clicking to pull up a context menu and selecting an option from the context menu. In response to the selection, the user interface 1400 may be generated. The two scenarios provided different paths for the route that beings with post/login 1405. The first scenario 1410 included finding a configuration and setting attributes. The second scenario 1415 included creating sessions, authenticating, and accessing the “users” database table. This accessing of the “users” database table is the reason that the post/login route was included in the user interface 1300 that was filtered to show the web services that accessed the “users” entity in the data model. Note again that the correlation between the web services and the functionality of the code to drill into the details provides insights to the developer not previously available.

FIG. 15 illustrates a method 1500 for interrogating an application and generating interaction mapping and user interfaces for navigating the interactions between the components of the application as discussed above with respect to FIGS. 11-14. The method 1500 may be performed by a computing system such as system 1100 as described with respect to FIG. 11. Method 1500 begins with obtaining (1505) data files including information captured about an application during a run of the application. For example, a recording component, such as recording component 1130 may record details about a run of an application, such as application 1125. For example, a number of test cases may be run on application 1125 and recorded by recording component 1130 that generates data files that include the captured data. The captured data may include function calls, database interactions, data flow, web services that the application utilizes, and so forth. The recording component 1130 may provide the data files.

The method may include generating (1510) a data library model based on the data files. For example, an analysis engine, such as analysis engine 1135 may analyze the data files to generate the data library model. The data library model may include steps performed by the application, code paths connecting the steps and other information correlated with the steps and code paths. For example, database schema information, web service information, and data structure information, or some combination of them, may be included and correlated with the steps and code paths. For example, information that indicates which functions access which web services, which database entities are accessed by which functions and web services, which data structures utilize any other components, and any other interactions that may be identified between the various features of the application are recorded in the data files.

The method may include providing (1515) a user interface for navigating the data library model. For example, the user interfaces 1200, 1300, and 1400 depicted with respect to FIGS. 12A-14 are example user interfaces provided for navigating the data library model. The user interface may include functionality to filter, drill down, sort, and otherwise navigate and query the data model for specific information relevant to the user.

The method may include receiving (1520) a selection of a data item from the user interface. For example, data items shown in the user interface may be available for selection to drill down, filter, or otherwise navigate the data library model. As a shown example, the user may have selected the post/login route 1320 in user interface 1300 described with respect to FIG. 13. This selection is provided to the system that receives the selection for further processing.

The method may also include identifying and displaying (1525) information correlated to the data item. For example, the information correlated to the data item may be filtered or otherwise drilled down information that is identified and displayed. As a shown example, the user selected the post/login route 1320 in user interface 1300 as described with respect to FIG. 13. In response, as shown in FIG. 14, the user interface 1400 is generated that shows the correlated information of the post/login route 1320 in a functional flow format as described with respect to FIG. 14.

While some examples provided herein are described in the context of an application modernization system, it should be understood that the systems and methods described herein are not limited to such embodiments and may apply to a variety of other software development processes and their associated systems. As will be appreciated by one skilled in the art, aspects of the present invention may be embodied as a system, method, computer program product, and other configurable systems. Accordingly, aspects of the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment (including firmware, resident software, micro-code, etc.) or an embodiment combining software and hardware aspects that may all generally be referred to herein as a “circuit,” “module” or “system.” Furthermore, aspects of the present invention may take the form of a computer program product embodied in one or more computer readable medium(s) having computer readable program code embodied thereon.

Unless the context clearly requires otherwise, throughout the description and the claims, the words “comprise,” “comprising,” and the like are to be construed in an inclusive sense, as opposed to an exclusive or exhaustive sense; that is to say, in the sense of “including, but not limited to.” As used herein, the terms “connected,” “coupled,” or any variant thereof means any connection or coupling, either direct or indirect, between two or more elements; the coupling or connection between the elements can be physical, logical, or a combination thereof. Additionally, the words “herein,” “above,” “below,” and words of similar import, when used in this application, refer to this application as a whole and not to any particular portions of this application. Where the context permits, words in the above Detailed Description using the singular or plural number may also include the plural or singular number respectively. The word “or,” in reference to a list of two or more items, covers all of the following interpretations of the word: any of the items in the list, all of the items in the list, and any combination of the items in the list.

The phrases “in some embodiments,” “according to some embodiments,” “in the embodiments shown,” “in other embodiments,” and the like generally mean the particular feature, structure, or characteristic following the phrase is included in at least one implementation of the present technology, and may be included in more than one implementation. In addition, such phrases do not necessarily refer to the same embodiments or different embodiments.

The above Detailed Description of examples of the technology is not intended to be exhaustive or to limit the technology to the precise form disclosed above. While specific examples for the technology are described above for illustrative purposes, various equivalent modifications are possible within the scope of the technology, as those skilled in the relevant art will recognize. For example, while processes or blocks are presented in a given order, alternative implementations may perform routines having steps, or employ systems having blocks, in a different order, and some processes or blocks may be deleted, moved, added, subdivided, combined, and/or modified to provide alternative or subcombinations. Each of these processes or blocks may be implemented in a variety of different ways. Also, while processes or blocks are at times shown as being performed in series, these processes or blocks may instead be performed or implemented in parallel, or may be performed at different times. Further any specific numbers noted herein are only examples: alternative implementations may employ differing values or ranges.

The teachings of the technology provided herein can be applied to other systems, not necessarily the system described above. The elements and acts of the various examples described above can be combined to provide further implementations of the technology. Some alternative implementations of the technology may include not only additional elements to those implementations noted above, but also may include fewer elements.

These and other changes can be made to the technology in light of the above Detailed Description. While the above description describes certain examples of the technology, and describes the best mode contemplated, no matter how detailed the above appears in text, the technology can be practiced in many ways. Details of the system may vary considerably in its specific implementation, while still being encompassed by the technology disclosed herein. As noted above, particular terminology used when describing certain features or aspects of the technology should not be taken to imply that the terminology is being redefined herein to be restricted to any specific characteristics, features, or aspects of the technology with which that terminology is associated. In general, the terms used in the following claims should not be construed to limit the technology to the specific examples disclosed in the specification, unless the above Detailed Description section explicitly defines such terms. Accordingly, the actual scope of the technology encompasses not only the disclosed examples, but also all equivalent ways of practicing or implementing the technology under the claims.

To reduce the number of claims, certain aspects of the technology are presented below in certain claim forms, but the applicant contemplates the various aspects of the technology in any number of claim forms. For example, while only one aspect of the technology is recited as a computer-readable medium claim, other aspects may likewise be embodied as a computer-readable medium claim, or in other forms, such as being embodied in a means-plus-function claim. Any claims intended to be treated under 35 U.S.C. § 112(f) will begin with the words “means for,” but use of the term “for” in any other context is not intended to invoke treatment under 35 U.S.C. § 112(f). Accordingly, the applicant reserves the right to pursue additional claims after filing this application to pursue such additional claim forms, in either this application or in a continuing application. 

What is claimed is:
 1. A system, comprising: one or more computer-readable storage media; a processing system operatively coupled with the one or more computer-readable storage media; and program instructions stored on the one or more computer-readable storage media that, when executed by the processing system, direct the processing system to at least: obtain one or more data files comprising information captured about an application during a run of the application; generate a data library model based on the one or more data files, wherein the data library model comprises one or more steps performed by the application and one or more code paths connecting the steps performed by the application, and the data library model comprises information about the application correlated with the one or more steps and the one or more code paths; and provide a user interface for navigating the data library model.
 2. The system of claim 1, wherein the information about the application comprises at least one of database schema information, web service information, data structure information, or a combination thereof.
 3. The system of claim 1, wherein the user interface comprises features for filtering the data library model.
 4. The system of claim 1, wherein the user interface comprises navigable data views of the information about the application, and wherein the user interface comprises functionality for filtering based on a selection of a data item in a data view by a user to identify other correlated information about the application.
 5. The system of claim 4, wherein the navigable data views comprise a navigable view of web services accessed by the application and a navigable view of database schema information used by the application.
 6. The system of claim 5, wherein the user interface further comprises functionality for a user to select a web service from the navigable view of web services to identify database schema information related to the selected web service.
 7. The system of claim 5, wherein the user interface further comprises functionality for a user to select a data item from the navigable view of database schema information to identify web services related to the selected data item.
 8. The system of claim 1, wherein the run of the application is requested by a user device remotely from an application server executing the application, and the user interface is accessed by the user device remotely.
 9. The system of claim 8, wherein the user device generates the one or more data files and transmits the one or more data files to the system.
 10. The system of claim 1, wherein the run of the application comprises executing automated test scripts.
 11. A computer-implemented method, comprising: obtain one or more data files comprising information captured about an application during a run of the application; generate a data library model based on the one or more data files, wherein the data library model comprises one or more steps performed by the application and one or more code paths connecting the steps performed by the application, and the data library model comprises information about the application correlated with the one or more steps and the one or more code paths; and provide a user interface for navigating the data library model.
 12. The computer-implemented method of claim 11, wherein the information about the application comprises at least one of database schema information, web service information, data structure information, or a combination thereof.
 13. The computer-implemented method of claim 11, wherein providing the user interface comprises providing features for filtering the data library model.
 14. The computer-implemented method of claim 11, wherein providing the user interface comprises providing navigable data views of the information about the application, and wherein providing the user interface further comprises providing functionality for filtering based on a selection of a data item in a data view by a user to identify other correlated information about the application.
 15. The computer-implemented method of claim 14, wherein the navigable data views comprise a navigable view of web services accessed by the application and a navigable view of database schema information used by the application.
 16. The computer-implemented method of claim 15, wherein providing the user interface further comprises: receiving a selection of a web service from the navigable view of web services; and identifying database schema information related to the selected web service.
 17. The computer-implemented method of claim 15, wherein providing the user interface further comprises: receiving a selection of a data item from the navigable view of database schema information; and identifying web services related to the selected data item.
 18. The computer-implemented method of claim 11, further comprising: receiving a request to perform the run of the application from a user device remotely from an application server executing the application, and providing the user interface to the user device remotely.
 19. The computer-implemented method of claim 18, further comprising: receiving the one or more data files from the user device.
 20. The computer-implemented method of claim 11, wherein the run of the application comprises executing automated test scripts. 